package com.yaolisheng.utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * @author yaolisheng
 * @version 1.0
 * @date 2021/5/5 12:16
 */
public final class CollectionUtils {
	
	public static final String LIST_SEPERATOR = ",";
	
	
	/**
	 * 将一个集合用指定分隔符连接为一个字符串
	 * @param c
	 * @param seperator
	 * @return
	 */
	public static String join(Collection<? extends Object> c, String seperator)
	{
		StringBuffer buf = new StringBuffer();
		
		if(!isEmpty(c))
		{
			for(Object o : c)
			{
				buf.append(seperator).append(o.toString());
			}
			if(buf.length() > 0) buf.delete(0, seperator.length());
		}
		return buf.toString();
	}
	
	
	/**
	 * 将一个集合用默认分隔符连接为一个字符串
	 * @param c
	 * @return
	 */
	public static String join(Collection<? extends Object> c)
	{
		return join(c, LIST_SEPERATOR);
	}
	
	/**
	 * 将一个集合用默认分隔符连接为一个字符串
	 * @return
	 */
	public static String join(Object[] a)
	{
		List<Object> c = new ArrayList<Object>();
		for(Object o : a)
		{
			c.add(o);
		}
		return join(c, LIST_SEPERATOR);
	}
	
	
	/**
	 * 分隔一个字符串到list数组
	 * @param string
	 * @param seperator
	 * @return
	 */
	public static List<String> split(String string, String seperator)
	{
		if(StringUtils.isNotEmpty(string))
		{
			String[] strs = string.split(seperator);
			if(isNotEmpty(strs))
			{
				return Arrays.asList(strs);
			}
		}
		return Collections.emptyList();
	}
	
	/**
	 * 分隔一个字符串到list数组
	 * @param string
	 * @return
	 */
	public static List<String> split(String string)
	{
		return split(string, LIST_SEPERATOR);
	}
	
	
	/**
	 * 判断一个集合是否为空
	 * @param c
	 * @return
	 */
	public static boolean isEmpty(Collection<? extends Object> c)
	{
		return c == null || c.isEmpty();
	}
	
	/**
	 * 判断一个集合是否不为空
	 * @param c
	 * @return
	 */
	public static boolean isNotEmpty(Collection<? extends Object> c)
	{
		return !isEmpty(c);
	}
	
	
	/**
	 * 判断一个Map是否为空
	 * @return
	 */
	public static boolean isEmpty(Map<? extends Object, ? extends Object> m)
	{
		return m == null || m.isEmpty();
	}
	
	/**
	 * 判断一个Map是否不为空
	 * @param c
	 * @return
	 */
	public static boolean isNotEmpty(Map<? extends Object, ? extends Object> m)
	{
		return !isEmpty(m);
	}
	
	
	/**
	 * 判断一个数组是否为空
	 * @param a
	 * @return
	 */
	public static boolean isEmpty(Object[] a)
	{
		return a == null || a.length == 0;
	}
	
	/**
	 * 判断一个数组是否不为空
	 * @param a
	 * @return
	 */
	public static boolean isNotEmpty(Object[] a)
	{
		return !isEmpty(a);
	}
	
	
	/**
	 * 判断一个对象是否是集合类型
	 * @param value
	 * @return
	 */
	public static boolean isCollection(Object value)
	{
		if(value == null) return false;
		if(value instanceof Collection<?>) return true;
		if(value instanceof Map<?, ?>) return true;
		if(value instanceof Object[]) return true; 
		return false;
	}
	
	/**
	 * 将集合对象拆分为一个数组
	 * @param value
	 * @return
	 */
	public static Object[] toArray(Object value)
	{
		if(isCollection(value))
		{
			if(value instanceof Collection<?>)
			{
				return ((Collection<?>) value).toArray();
			}
			else if(value instanceof Map<?, ?>)
			{
				return ((Map<?, ?>)value).values().toArray();
			}
			else if(value instanceof Object[])
			{
				return (Object[]) value;
			}
		}
		return null;
	}
	
}
